{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import AutoTokenizer, AutoModel, AutoConfig\n",
    "import torch\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import KFold\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import wandb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "        self.backbone = 'microsoft/deberta-v3-base'\n",
    "        self.max_length = 512\n",
    "\n",
    "        self.model_path = './cache'\n",
    "        self.checkpoint_path = './checkpoints'\n",
    "        self.dataset_path = './input/feedback-prize-english-language-learning'\n",
    "\n",
    "        self.epoch = 0\n",
    "        self.n_epochs = 3\n",
    "        self.batch_size = 16\n",
    "\n",
    "        self.n_cpus = 0\n",
    "        self.n_splits = 5\n",
    "\n",
    "        # loss function\n",
    "        self.criterion = 'SmoothL1Loss'\n",
    "\n",
    "        # optimizer\n",
    "        # self.optimizer='Adam'\n",
    "        self.lr = 5e-4\n",
    "        self.b1 = 0.9\n",
    "        self.b2 = 0.999\n",
    "        self.eps = 1e-6\n",
    "\n",
    "        # scheduler # did not use\n",
    "        self.scheduler = 'CosineAnnealingWarmRestarts'\n",
    "        self.T_0 = 5\n",
    "        self.eta_min = 1e-6\n",
    "\n",
    "        self.use_wandb = False\n",
    "\n",
    "\n",
    "config = Config()\n",
    "\n",
    "device = config.device\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if config.use_wandb:\n",
    "    run = wandb.init(project='FDB3',\n",
    "                     name=config.backbone,\n",
    "                     config=config,\n",
    "                     group=config.backbone,\n",
    "                     job_type=\"train\",\n",
    "                     )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n",
      "d:\\ProgramData\\Anaconda3\\envs\\py38\\lib\\site-packages\\transformers\\convert_slow_tokenizer.py:470: UserWarning: The sentencepiece tokenizer that you are converting to a fast tokenizer uses the byte fallback option which is not implemented in the fast tokenizers. In practice this means that the fast version of the tokenizer can produce unknown tokens whereas the sentencepiece version would have converted these unknown tokens into a sequence of byte tokens matching the original piece of text.\n",
      "  warnings.warn(\n",
      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
     ]
    }
   ],
   "source": [
    "# download or load model & tokenizer\n",
    "\n",
    "'''run the code below if you are running this code for the first time'''\n",
    "# tokenizer = AutoTokenizer.from_pretrained(\n",
    "#     pretrained_model_name_or_path=config.backbone, cache_dir=config.model_path)\n",
    "# model_config = AutoConfig.from_pretrained(\n",
    "#     pretrained_model_name_or_path=config.backbone,cache_dir=config.model_path,output_hidden_states=True,)\n",
    "\n",
    "# encoder = AutoModel.from_pretrained(\n",
    "#     pretrained_model_name_or_path=config.backbone,cache_dir=config.model_path)\n",
    "\n",
    "\n",
    "tail = '\\models--microsoft--deberta-v3-base\\snapshots\\8ccc9b6f36199bec6961081d44eb72fb3f7353f3'\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(\n",
    "    pretrained_model_name_or_path=config.model_path+tail)\n",
    "\n",
    "model_config = AutoConfig.from_pretrained(\n",
    "    pretrained_model_name_or_path=config.model_path+tail, output_hidden_states=True,)\n",
    "\n",
    "encoder = AutoModel.from_pretrained(\n",
    "    pretrained_model_name_or_path=config.model_path+tail)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "num of parameters:\n",
      "total:184.029958M\n",
      "freeze:183.831552M\n",
      "unfreeze:0.198406M\n",
      "unfreeze/total:0.107812%\n"
     ]
    }
   ],
   "source": [
    "# load model\n",
    "from Frozenbert.pool_model import Frozenbert\n",
    "\n",
    "# create model\n",
    "net = Frozenbert(model_config, encoder).to(device)\n",
    "\n",
    "# freeze encoder\n",
    "for param in net.encoder.parameters():\n",
    "    param.requires_grad = False\n",
    "\n",
    "# unfreeze last layers\n",
    "# num_unfreeze=2\n",
    "# for param in net.encoder.encoder.layer[-num_unfreeze:].parameters():\n",
    "#     param.requires_grad = True\n",
    "\n",
    "# count num of parameters\n",
    "total = sum([param.nelement() for param in net.parameters()])\n",
    "freeze = sum([param.nelement()\n",
    "              for param in net.parameters() if param.requires_grad == False])\n",
    "unfreeze = sum([param.nelement()\n",
    "                for param in net.parameters() if param.requires_grad == True])\n",
    "print('\\nnum of parameters:')\n",
    "print(\"total:%fM\" % (total/1e6))\n",
    "print(\"freeze:%fM\" % (freeze/1e6))\n",
    "print(\"unfreeze:%fM\" % (unfreeze/1e6))\n",
    "print(\"unfreeze/total:%f%%\" % (unfreeze/total*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data frame\n",
    "df = pd.read_csv(config.dataset_path+'/train.csv')\n",
    "test_df = pd.read_csv(config.dataset_path+'/test.csv')\n",
    "\n",
    "# Create a KFold cross-validator\n",
    "kf = KFold(n_splits=config.n_splits, shuffle=True, random_state=1357)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.classes import EssayDataset\n",
    "from utils.classes import Trainer\n",
    "\n",
    "def train_fold(model, train_df, val_df, test_df, config, epoch):\n",
    "    # Prepare data\n",
    "    train_ds = EssayDataset(train_df, config, tokenizer=tokenizer)\n",
    "    val_ds = EssayDataset(val_df, config, tokenizer=tokenizer)\n",
    "    # test_ds = EssayDataset(test_df, config, tokenizer=tokenizer, is_test=True)\n",
    "\n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        train_ds, batch_size=config.batch_size, shuffle=True, num_workers=config.n_cpus, pin_memory=True)\n",
    "    val_loader = torch.utils.data.DataLoader(\n",
    "        val_ds, batch_size=config.batch_size, shuffle=True, num_workers=config.n_cpus, pin_memory=True)\n",
    "    # test_loader = torch.utils.data.DataLoader(test_ds, batch_size=1, shuffle=True, num_workers=0, pin_memory=True)\n",
    "\n",
    "    # Create a trainer and train the model\n",
    "    trainer = Trainer(model=model, loaders=(\n",
    "        train_loader, val_loader), config=config)\n",
    "\n",
    "    current_lr = trainer.optimizer.param_groups[0]['lr']\n",
    "\n",
    "    # Start training\n",
    "    trainer.model.train()\n",
    "    trainer.train_one_epoch(epoch)\n",
    "    trainer.clear()\n",
    "\n",
    "    trainer.model.eval()\n",
    "    trainer.valid_one_epoch(epoch)\n",
    "    trainer.clear()\n",
    "\n",
    "    # Test result after training\n",
    "    # preds = trainer.test(test_loader=test_loader)\n",
    "    # print(\"Test result after training:\\n\", preds)\n",
    "\n",
    "    # Calculate and return mean loss and MCRMSE\n",
    "    mean_train_loss = np.mean(trainer.train_losses)\n",
    "    mean_valid_loss = np.mean(trainer.valid_losses)\n",
    "    mean_valid_mcrmse = np.mean(trainer.valid_mcrmse)\n",
    "\n",
    "    print('current lr: {:.7f}'.format(current_lr))\n",
    "    print('train_loss: %.2f, valid_loss: %.2f, val_mcrmse: %.2f' %\n",
    "          (mean_train_loss, mean_valid_loss, mean_valid_mcrmse))\n",
    "\n",
    "    return mean_train_loss, mean_valid_loss, mean_valid_mcrmse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists to store results from each fold\n",
    "\n",
    "global fold_train_losses\n",
    "global fold_val_losses\n",
    "global fold_val_mcrmse\n",
    "global min_mcrmse\n",
    "global best_model\n",
    "\n",
    "fold_train_losses = []\n",
    "fold_valid_losses = []\n",
    "fold_valid_mcrmse = []\n",
    "min_mcrmse = float(\"inf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "++++++++++++++++++++++++++++++ Fold 1/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:47<00:00,  1.83it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.22, valid_loss: 0.11, val_mcrmse: 0.47\n",
      "++++++++++++++++++++++++++++++ Fold 2/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.12, valid_loss: 0.12, val_mcrmse: 0.48\n",
      "++++++++++++++++++++++++++++++ Fold 3/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.11, valid_loss: 0.13, val_mcrmse: 0.49\n",
      "++++++++++++++++++++++++++++++ Fold 4/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.11, valid_loss: 0.15, val_mcrmse: 0.54\n",
      "++++++++++++++++++++++++++++++ Fold 5/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.11, valid_loss: 0.11, val_mcrmse: 0.47\n",
      "------------------------------ EPOCH 1 / 3 ------------------------------\n",
      "mean train loss: 0.1351610795347666\n",
      "mean valid loss: 0.12481764123147847\n",
      "mean valid mcrmse: 0.49328068178527207\n",
      "\n",
      "\n",
      "++++++++++++++++++++++++++++++ Fold 1/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.89it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.11, valid_loss: 0.11, val_mcrmse: 0.47\n",
      "++++++++++++++++++++++++++++++ Fold 2/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.11, valid_loss: 0.11, val_mcrmse: 0.46\n",
      "++++++++++++++++++++++++++++++ Fold 3/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.10, valid_loss: 0.11, val_mcrmse: 0.47\n",
      "++++++++++++++++++++++++++++++ Fold 4/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.11, valid_loss: 0.12, val_mcrmse: 0.47\n",
      "++++++++++++++++++++++++++++++ Fold 5/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.11, valid_loss: 0.16, val_mcrmse: 0.55\n",
      "------------------------------ EPOCH 2 / 3 ------------------------------\n",
      "mean train loss: 0.12074656301767242\n",
      "mean valid loss: 0.12291895955496905\n",
      "mean valid mcrmse: 0.4889821773889113\n",
      "\n",
      "\n",
      "++++++++++++++++++++++++++++++ Fold 1/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.10, valid_loss: 0.11, val_mcrmse: 0.45\n",
      "++++++++++++++++++++++++++++++ Fold 2/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.10, valid_loss: 0.13, val_mcrmse: 0.50\n",
      "++++++++++++++++++++++++++++++ Fold 3/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.10, valid_loss: 0.12, val_mcrmse: 0.48\n",
      "++++++++++++++++++++++++++++++ Fold 4/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:22<00:00,  2.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.10, valid_loss: 0.10, val_mcrmse: 0.44\n",
      "++++++++++++++++++++++++++++++ Fold 5/5 ++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:43<00:00,  1.90it/s]\n",
      "100%|██████████| 49/49 [00:23<00:00,  2.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr: 0.0005000\n",
      "train_loss: 0.10, valid_loss: 0.12, val_mcrmse: 0.48\n",
      "------------------------------ EPOCH 3 / 3 ------------------------------\n",
      "mean train loss: 0.11459966647711133\n",
      "mean valid loss: 0.11991392456147136\n",
      "mean valid mcrmse: 0.4828651560001632\n",
      "\n",
      "\n",
      "min mcrmse:  0.4422356382924683\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(config.epoch+1, config.epoch+config.n_epochs + 1):\n",
    "\n",
    "    # Iterate over the cross-validation splits\n",
    "    for fold, (train_index, val_index) in enumerate(kf.split(df)):\n",
    "        print(f\"{'+'*30} Fold {fold + 1}/{config.n_splits} {'+'*30}\")\n",
    "\n",
    "        train_fold_df = df.iloc[train_index]\n",
    "        val_fold_df = df.iloc[val_index]\n",
    "\n",
    "        # Train the model on the fold and store validation results\n",
    "        mean_train_loss, mean_valid_loss, mean_valid_mcrmse = train_fold(\n",
    "            net, train_fold_df, val_fold_df, test_df, config, epoch)\n",
    "\n",
    "        # Store the validation loss and MCRMSE for this fold\n",
    "        fold_train_losses.append(mean_train_loss)\n",
    "        fold_valid_losses.append(mean_valid_loss)\n",
    "        fold_valid_mcrmse.append(mean_valid_mcrmse)\n",
    "\n",
    "        if mean_valid_mcrmse < min_mcrmse:\n",
    "            min_mcrmse = mean_valid_mcrmse\n",
    "            best_model = net\n",
    "\n",
    "    print(f\"{'-' * 30} EPOCH {epoch} / {config.n_epochs+config.epoch} {'-' * 30}\")\n",
    "    print(f\"mean train loss: {np.mean(fold_train_losses)}\")\n",
    "    print(f\"mean valid loss: {np.mean(fold_valid_losses)}\")\n",
    "    print(f\"mean valid mcrmse: {np.mean(fold_valid_mcrmse)}\\n\\n\")\n",
    "\n",
    "    # save model\n",
    "    save_name = '/FrozenBert-epochs%d-val_mcrmse%.4f.pth' % (epoch, min_mcrmse)\n",
    "    torch.save(best_model, config.checkpoint_path+save_name)\n",
    "\n",
    "    # wandb\n",
    "    if config.use_wandb:\n",
    "        wandb.log({\n",
    "            \"train_loss\": fold_train_losses[-1],\n",
    "            \"valid_loss\": fold_valid_losses[-1],\n",
    "            \"valid_mcrmse\": fold_valid_mcrmse[-1], })\n",
    "\n",
    "print('min mcrmse: ', min_mcrmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Test Predictions:\n",
      "\n",
      "essay1---cohesion: 3.04, syntax: 2.94, vocabulary: 3.27, phraseology: 3.21, grammar: 2.78, conventions: 2.68\n",
      "essay2---cohesion: 2.85, syntax: 2.67, vocabulary: 2.96, phraseology: 2.63, grammar: 2.26, conventions: 2.85\n",
      "essay3---cohesion: 3.69, syntax: 3.57, vocabulary: 3.70, phraseology: 3.76, grammar: 3.45, conventions: 3.38\n"
     ]
    }
   ],
   "source": [
    "# Test on best model\n",
    "test_ds = EssayDataset(test_df, config, tokenizer=tokenizer, is_test=True)\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    test_ds, batch_size=1, shuffle=True, num_workers=0, pin_memory=True)\n",
    "\n",
    "best_model.eval()\n",
    "preds = []\n",
    "\n",
    "for inputs in test_loader:\n",
    "    inputs = {k: inputs[k].to(device)for k in inputs.keys()}\n",
    "    outputs = best_model(inputs)\n",
    "    preds.extend(outputs.cpu().detach())\n",
    "\n",
    "print(\"Final Test Predictions:\\n\")\n",
    "for i in range(len(test_loader)):\n",
    "    print('essay%d---cohesion: %.2f, syntax: %.2f, vocabulary: %.2f, phraseology: %.2f, grammar: %.2f, conventions: %.2f'\n",
    "          % (i+1, preds[i][0], preds[i][1], preds[i][2], preds[i][3], preds[i][4], preds[i][5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "if config.use_wandb:\n",
    "    wandb.finish()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot loss\n",
    "f, ax = plt.subplots(1, 2, figsize=(8, 4))\n",
    "\n",
    "# x_axis\n",
    "xx = range(1, len(fold_train_losses)+1)\n",
    "\n",
    "ax[0].plot(xx, fold_train_losses, color='red')\n",
    "ax[0].plot(xx, fold_valid_losses, color='orange')\n",
    "ax[0].set_title('Train & Val Loss')\n",
    "ax[0].legend(['Train', 'Validation'], loc='upper right')\n",
    "\n",
    "ax[1].plot(xx, fold_valid_mcrmse,  color='green')\n",
    "ax[1].set_title('Val MCRMSE Loss')\n",
    "ax[1].legend(['Validation'], loc='best')\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.18"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
